System and method for message management across a network

ABSTRACT

Systems, methods, and computer-readable media for managing service calls over a network may include a signal routing engine with a maintained forwarding table for various network functions and micro-services in a services back end for the network. The signal routing engine can include a call conversion service for converting REST API calls to an internal network call protocol for increasing network function processing speeds, decreasing bandwidth usage, and improving network responsiveness and manageability.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a Continuation of U.S. application Ser. No. 16/044,288, entitled “SYSTEM AND METHOD FOR MESSAGE MANAGEMENT ACROSS A NETWORK,” filed on Jul. 24, 2018, the content of which is incorporated herein by reference in its entirety.

TECHNICAL FIELD

The present technology pertains to network configuration and signal processing.

BACKGROUND

5G mobile networking must meet ever more diverse demands. Generally, the demands on a 5G mobile network can impact the number of sustainable connections, latency, and throughput across the network. As the number of devices connected over 5G networks increases, an exponential number of connections increases as well; applications such as self-driving cars often require ultralow latency connections; and, as compared to 4G networks, the throughput requirements on 5G networks is often a thousand times higher than on 4G networks, thus requiring vast numbers of representational state transfer (REST) calls over hypertext transfer protocol (HTTP) connections between various network functions (NF) underpinning 5G networks.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the disclosure can be obtained, a more particular description of the principles briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only exemplary embodiments of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIG. 1A depicts a service based illustration of an example network environment;

FIG. 1B depicts a reference point representation architectural model of an example network;

FIG. 2 depicts an example call sequence adhering to 5G standards;

FIG. 3 illustrates an example signal routing engine;

FIG. 4 depicts an example call sequence including the signal routing engine of FIG. 3;

FIG. 5 illustrates an example method for routing signals;

FIG. 6 illustrates an example network device; and

FIG. 7 illustrates an example computing device.

DESCRIPTION OF EXAMPLE EMBODIMENTS

Various embodiments of the disclosure are discussed in detail below. While specific implementations are discussed, it should be understood that this is done for illustration purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without parting from the spirit and scope of the disclosure. Thus, the following description and drawings are illustrative and are not to be construed as limiting. Numerous specific details are described to provide a thorough understanding of the disclosure. However, in certain instances, well-known or conventional details are not described in order to avoid obscuring the description. References to one or an embodiment in the present disclosure can be references to the same embodiment or any embodiment; and, such references mean at least one of the embodiments.

Reference to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the disclosure. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Moreover, various features are described which may be exhibited by some embodiments and not by others.

The terms used in this specification generally have their ordinary meanings in the art, within the context of the disclosure, and in the specific context where each term is used. Alternative language and synonyms may be used for any one or more of the terms discussed herein, and no special significance should be placed upon whether or not a term is elaborated or discussed herein. In some cases, synonyms for certain terms are provided. A recital of one or more synonyms does not exclude the use of other synonyms. The use of examples anywhere in this specification including examples of any terms discussed herein is illustrative only, and is not intended to further limit the scope and meaning of the disclosure or of any example term. Likewise, the disclosure is not limited to various embodiments given in this specification.

Without intent to limit the scope of the disclosure, examples of instruments, apparatus, methods and their related results according to the embodiments of the present disclosure are given below. Note that titles or subtitles may be used in the examples for convenience of a reader, which in no way should limit the scope of the disclosure. Unless otherwise defined, technical and scientific terms used herein have the meaning as commonly understood by one of ordinary skill in the art to which this disclosure pertains. In the case of conflict, the present document, including definitions will control.

Additional features and advantages of the disclosure will be set forth in the description which follows, and in part will be obvious from the description, or can be learned by practice of the herein disclosed principles. The features and advantages of the disclosure can be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the disclosure will become more fully apparent from the following description and appended claims, or can be learned by the practice of the principles set forth herein.

OVERVIEW

A 5G network architecture may be a service based architecture (SBA) in which various services within NFs use REST application programming interface (API) calls over HTTP/2 as a control plane signaling protocol. In a system deployed to some degree over a cloud native environment (CNE), these services may have one or multiple HTTP/2 terminating endpoints which may be dynamically added or removed to facilitate respective scaling and descaling of the system. In particular, CNE services can be started on different server blades, virtual machines (VMs), containers and the like depending on resource availability. As a result, signaling (e.g., message handling) and connection management can become difficult as message routing becomes more complex in tandem with more services being added to the system.

Furthermore, in the case of container orchestration and management, creation of new virtual network functions (VNFs) to support containers and automatic learning of configuration changes may add additional traffic load to the network that is difficult to manage. It may take considerable time to determine where a request should be forwarded to and/or how to forward it. Geographic location, data center location, and similar factors may need to be determined in order to properly forward requests and each of these determinations may require further series of REST API calls and other requests in order to complete.

In a particular embodiment, a network function endpoint address may be received and stored in a forwarding table. Further, a requestor may make a web protocol (e.g., HTTP/2 and the like) directed to the network function endpoint. The web protocol call may be converted into a micro-services protocol (e.g., gRPC) and transmitted to the network function endpoint by using the address stored in the forwarding table. A response, in the micro-services protocol, can then be received from the network function endpoint and converted into the web protocol before being transmitted to the requestor.

EXAMPLE EMBODIMENTS

A signal routing engine for 5G (5GSRE) can receive requests and otherwise manage signal routing in order to increase efficiency and scalability across the network. For example, the 5GSRE can manage external HTTP connections and provide lightweight, efficient, and/or easily updated protocols for internal network communications (e.g., between micro-services and the like). For internal network services, a more efficient protocol, such as gRPC and the like may be utilized for communications instead of REST format.

In comparison, where a request is received from outside the internal network (e.g., another network) and is directed to an internal network service, the 5GSRE can receive the call, convert it into an appropriate internal protocol and transmit it to the intended recipient service in a more efficient format and protocol before inverting the process on any output produced in response to the request.

The 5GSRE can dynamically add or remove a stored listing of network functions (NFs) as the respective network grows and shrinks. NFs can include, for example and without imputing limitation, virtualization functions, reporting functions, logging functions, and the like. For example, as seen in Table 1 below, a service listing table can be stored on the 5GSRE in, for example, memory and provide for internet protocol (IP) address mappings for each service. Table 1 maps each service name, or NF, to an endpoint (EP) and a location:

TABLE 1 Service Name EP Location Service 1 IP1:3868, IP2:3869 Blade-1, VM1 Service 2 IP3:3868 Blade-2, VM2 Service 3 IP:27717 Blade-1, VM3 . . . . . . . . .

Table 1 and the like may be stored in, for example, a routing registry which is accessible by NFs and may be updated by a network repository function (NRF) and the like. Updates may occur upon discovery of a new NF or detection of a NF failure and the like. Generally, where a call to, for example, Service 1 is made via a NF, the NF can query the routing registry for the proper IP address to which to direct the call. The routing registry can look up the IP address, or EP, for the designated service by searching an internally stored table such as Table 1 above. Accordingly, as services are discovered on the network and added to the stored table, queries may take an increasingly longer time to complete.

In addition, where requests are transmitted over HTTP using REST API calls, each recipient NF may need to decode each received request from a REST format (e.g., JavaScript Object Notation (JSON) and the like) for internal processing and then encode output into the same format before transmitting the response. In some examples, decoding can involve tedious and compute-intensive processing techniques such as string parsing and the like in order to convert, for example, a JSON request into a format usable internally to by the receiving NF. Further, REST format transmissions may generally include more data overall and so make for, relative to inherently serialized techniques for example, inefficient communications.

However, in one embodiment, the 5GSRE can maintain a forwarding table in order to speed up searches and also reduce connection management complexity by centralizing and reducing the number of calls between services. By consolidating lookup and routing processes to the 5GSRE, faster lower level interface (e.g., a southbound interface (SBI) layer) protocols may be used instead of more complex interface protocols such as those used in a northbound interface (NBI) layer for communication between services.

In general, the 5GSRE can receive a request or call from, for example, a user device or other user equipment. For example, a user device such as a smartphone and the like may attempt an attach procedure which will generate an initial request transmitted to an access and mobility management function (AMF). As a smartphone transitions between network coverage, new network sessions with respective changing networks can be created to ensure continued connectivity. Initiation of these network sessions is referred to as an “attach procedure” and can include transmitting an attach request to a nearby network node.

As a smartphone attaches to different networks, either the device itself or the AMF it is linked to, may need “slice” information in order to properly connect to the network. Generally, a network slice denotes a logical grouping of network resources across a network. This logical grouping can be based on various factors such as, without limitation, industry, subscription, network management factors such as congestion and the like, and various other factors as will be understood by a person having ordinary skill in the art. For example, a user device associated with emergency services or first responders may be assigned to an ultralow latency slice, or a slice may only include devices having a threshold security level in order to process sensitive transmissions, and the like. Nevertheless, it may be necessary to retrieve slice identification when a device performs an attach or similar procedure.

In one embodiment, the AMF may transmit to the 5GSRE a request for slice information. In contrast, a typical attach request may otherwise be transmitted from the AMF directly to a network slice selection function (NSSF) as a REST API call including, for example, a “GET” query, in Standard Query Language (SQL) format, for slice information. With a REST call, the NSSF will then need to convert the REST format into an internal format in order to process the call and produce output, which must likewise be converted between the internal format and the REST format.

In the case of an attach procedure, the slice information can then be used to reach a desired NF instance which may assign a quality of service (QoS). The QoS may then be further impact a quality of experience (e.g., with the appropriate QoS) for the “attach” device. The QoS selection can be based on various factors, such as, for example and without imputing limitation, a subscription plan associated with the device and the like. The QoS may be assigned by a policy control function (PCF) and the PCF may interact, directly or indirectly, with a session management function (SMF) to maintain the session, or window of attachment, to the attaching device (e.g., smartphone).

In the typical attach procedure, the AMF may use the slice information to transmit a REST “POST” SQL statement directly to the SMF. As a result, the SMF may transmit a REST GET SQL query to the PCF in order to determine a proper QoS to assign to the session. The responses for each transmission may similarly be transmitted as REST format SQL statements (e.g., a REST POST statement and the like).

In comparison, in one embodiment, the AMF may transmit a session creation message to the SMF which in turn can retrieve QoS information by interfacing with the 5GSRE. The SMF may transmit a query call to the PCF in a non-REST format. The PCF can transmit the appropriate QoS information back to the 5GSRE in response. The 5GSRE may then transmit the QoS information to the SMF which in turn can finalize the session. Once the session is finalized, the SMF may transmit notice to the AMF which itself notifies the attaching device that the attachment procedure has completed and that the device is now attached to the network.

In some embodiments, the 5GSRE may register with a NRF in order to maintain proper routing, via a forwarding table, to newly added services in the network. Likewise, by registering with the NRF and performing, for example, regular synchronization procedures or validation checks, the 5GSRE may remove from its forwarding table services which are no longer available in order to reduce overhead processing and the like. In another example, a subscription based policy can be utilized by the 5GSRE to receive notifications of changes to the NRF. The notification may include identification of a particular service and whether it has been added to the NRF or removed from the NRF. If the service has been added to the NRF, an endpoint or IP address may also be included with the notification. Further, any changes to services, such as additional endpoint locations, can also be provided as notification.

The 5GSRE can also include routing rules and the like to be applied to messages in tandem with the forwarding table. For example, where a service is associated with multiple endpoints, the 5GSRE may forward messages to a particular endpoint based on, without limitation, geographical location of the requestor, subscription type of the requestor, network congestion, availability status of other endpoints, and various other considerations as will be apparent to a person having ordinary skill in the art.

In some embodiments, the 5GSRE may be run as multiple instances within a data center. A Global 5GSRE (e.g., a master 5GSRE which can control other 5GSREs) may replicate new or changed data to all of the 5GSRE instances running within the data center. Further, the 5GSRE instances may be registered with the Global 5GSRE to support service across multiple data centers (e.g., a 5GSRE may be in a first data center and a service within its forwarding table in a second data center) in order to support geographically aware capabilities for NFs.

Turning to FIGS. 1A and 1B, mobile networking environments 100 and 150 are illustrated in a service-based and point reference-based depiction respectively. A typical mobile networking environment 100, 150 enables user devices to move from one network to another network and the like while, for example, moving through areas with coverage by various networks.

A services back end 102 and 152 includes various services for managing API calls and the like over the network. In particular, each service may be run as a micro-service, in which case it will be accessible at, for example, an endpoint associated with an IP address and the like. The micro-services can be executed by dedicated circuits, installed programs, VMs, and the like. Other configurations may execute the services as will be apparent to a person having ordinary skill in the art.

As depicted in FIG. 1A, under the service-based architecture, services may communicate with each other over a communications bus 130. Access and mobility management function (AMF) 118 may receive connection requests and the like either directly from a user device, here a smartphone 122, or over a radio access network (RAN) 124. In some examples, RAN 124 can include various towers, stations, and hops facilitating wireless networked communications as will be apparent to a person having ordinary skill in the part.

Nevertheless, AMF 118 can manage network connections of smartphone 122 by communicating over communications bus 130, or directly via point to point transmission as depicted by FIG. 1B, to the various micro-services of the services back end 102, 152. In the services-based architecture, the micro-services may include application function (AF) 104, network slice selection function (NSSF) 106, network exposure function (NEF) 108, network repository function (NRF) 110, policy control function (PCF) 112, unified data management (UDM) 114, authentication server function (AUSF) 116, and session management function (SMF) 120.

AMF 118 can interface with ASF 116 in order to validate an account associated with smartphone 122 and the like. Having validated the account, AMF 118 can then interface with NSSF 106 in order to determine an appropriate network slice to which smartphone 122 may have access. In some configurations, this can also determine particular micro-service endpoints with which AMF 118 and/or SMF 120 will interface. For example, for applications requiring low or ultralow latency, NSSF 106 may identify a network slice located as geographically proximate as possible in order to reduce transmission distance for micro-services between each other and/or the application.

AMF 118 may then interface with SMF 120 to manage a connection session for smartphone 122 over the network. PCF 112 in order to determine information related to, for example, a subscription package related to smartphone 122. For example, PCF 112 may determine a QoS and the like at which smartphone 122 can communicate across RAN 124.

NRF 110 can provide various state updates to interfacing services. For example, AMF 118 may maintain a cache of NSSF 106 endpoints and the like for performing the operations discussed above. UDM 114 and AF 104 may also interface with the various other micro-services connected to communications bus 130.

Smartphone 122 network access over RAN 124 may be further managed by a user plane function (UPF) 126 which interfaces with SMF 120. Whereas AMF 118 manages smartphone 122 joining and leaving the network, and thus being serviced by services back end 102, SMF 120 may manage smartphone 122 network usage and access via UPF 126. For example, and without imputing limitation, SMF 120 can inform UPF 126 how to process data from other data networks 128 (e.g., website access and the like).

Turning to FIG. 1B, in mobile networking environment 100, micro-services interface via point-to-point transmissions rather than along a communications bus. Services back end 152 may include the same micro-services as those found in services back end 102 (e.g., AF 104, PCF 112, AUSF 116, NSSF 106, UDM 114, SMF 120, AMF 118). Further, as with service-based architecture 100, point reference-based architecture 150 includes smartphone 122 in communication with and over RAN 124. UPF 126 manages network access by smartphone 122 along with communications by smartphone 122 with data networks 128.

However, as can be seen, AMF 118 may communicate directly with UDM 114, AUSF 116, and NSSF 106. Under the point reference-based architecture 150, AMF 118 and SMF 120 may also communicate directly with each other. SMF 120 may further communicate with UDM 114 and PCF 112. Further, PCF 112 can directly communicate with AUSF 116 and AF 104.

FIG. 2 depicts a call sequence diagram 200 for an attach procedure which may be conducted by either of service-based architecture 100 or point reference-based architecture 150. In particular, sequence diagram 200 depicts each step and signal or message transmission between relevant entities when user equipment (UE) 202 (e.g., smartphone 122) attaches to a new network.

Prior to UE 202 attaching, AMF 118 transmits signal 2.01 to NRF 110. Signal 2.01 may be a REST GET request for discovery of NSSF 106 endpoints. For example, signal 2.01 may include a REST API call with a SQL statement such as “GET/nrf/v1/nrf-disco/search” which is parsed by NRF 110 from the REST call (e.g., a JSON object containing a SQL statement in a field) and then processed as a SQL statement. Here, the SQL statement is in fact a query for information related to NSSF 106.

In response, NRF 110 returns to AMF 118 signal 2.02 which includes a list of NSSF 106 endpoints. As a result, AMF 118 transmits signal 2.03 to itself in order to maintain a cache of NSSF 106 information. In some examples, AMF 118 may further include subservices and the like and thus signal 2.03 may be passed from one subservice to another.

Independently, SMF 120 may transmit to NRF 110 signal 2.04, which may also be a REST GET request for discovery of PCF 112 endpoints. For example, signal 2.4 may include a REST API call with a SQL query statement such as “GET/nrf/v1/nrf-disco/search” which can cause NRF 110 to transmit a signal 2.05 containing a list of PCF 112 endpoints to SMF 120. Similarly to AMF 118, SMF 120 may then transmit a signal 2.06 to itself to update or maintain a cache of PCF 112 endpoints. SMF 120 may, in some examples, also be composed of various subservices and process and thus signal 2.06 may be transmitted from one subservice to another.

At a later point, UE 202 may transmit to AMF 118 signal 2.07 indicating an attach request. For example, UE 202 may have moved into an appropriate network during travel or may be switching from one network to another and the like. Nevertheless, AMF 118 may receive signal 2.07 and, as a result, transmit to NSSF 106, identified within an updated cache, signal 2.08 including a REST API call providing a GET statement for slice information. For example, the GET statement for slice information may include “GET /nssf/v1/nssf-get/select” and the like. In response, NSSF 106 may return signal 2.09 containing slice information.

In response to returned signal 2.09, AMF 118 may transmit to SMF 120 signal 2.10 containing a REST API call with a POST statement for generating a new session for UE 202. For example, the POST statement may include “POST/smf/v1/pdusession<pdu>” and the like, which, when received by SMF 120, may cause it to transmit to PCF 112 signal 2.11. Signal 2.11 may include a REST API call with a GET statement for retrieving a QoS associated with UE 202. For example, the GET statement may include “GET/pcf/v1/qosinfo” and the like. PCF 112 may then return signal 2.12 containing respective QoS information.

Having the QoS information, SMF 120 may then transmit to AMF 118 signal 2.13 including a REST API call having a POST statement. The POST statement may include a response statement as determined by, for example, the network, UE 202 preferences, or various other factors as will be understood by a person having ordinary skill in the art. AMF 118, as a result, can transmit signal 2.14 to UE 202 informing it that the attachment procedure has completed and that UE 202 is now on the requested network.

FIG. 3 depicts a network environment 300 including a signal routing engine 320. In particular, FIG. 3 depicts one embodiment of a 5GSRE signal routing engine 320. Signal routing engine 320 can be a software executed routing engine, a VM, or a hardware routing engine in the form of an integrated circuit and the like. For example, a software executed routing engine may perform as a monolith service and generate outputs through an obfuscated, or “blackboxed,” process. As another example, in comparison, a VM executing the routing engine may include various micro-services within the VM communicating endpoint-to-endpoint internally to the VM and over which reporting frameworks may be overlaid and the like, as will be apparent to a person having ordinary skill in the art.

Signal routing engine 320 may receive a transmission from, for example, third party UDM 330. Third party UDM 330 may include various signals such as device attachment requests, update requests, service configuration requests, and the like as will be apparent to a person having ordinary skill in the art. In particular, a HTTP/2 routing management service 328 within signal routing engine 320 receives the transmission from third party UDM 330.

HTTP/2 routing management service may then determine whether the received request is to be transmitted to a service back end 302 or to a third-party service. Where it is determined that a third-party service is the intended recipient, signal routing engine 320 can rebroadcast the signal back out to the intended recipient over the larger HTTP/2 network in its original format. However, if the signal is intended for one of micro-services 304-312 of service back end 302, then HTTP/2 routing management may query a forwarding table 324 to identify a micro-service endpoint for the transmission.

In some examples, where multiple endpoints are associated with a target micro-service, HTTP/2 routing management service 328 can determine a particular endpoint to which the received signal may be transmitted. HTTP/2 routing management service 328 may use rules-based logic, predetermined or dynamically determined, learned logic (e.g., applying a trained model and the like), or a mixture of the two in selecting an endpoint.

In other examples, forwarding table 324 may include stored rules for selecting an endpoint. Said rules may be stored in a routing rules and configurations data store 326. Routing rules and configurations data store 326 may store endpoint selection rules and the like, as well as information for populating forwarding table 324 with micro-services including endpoint entries. Routing rules and configurations data store 326 can be updated by NRF 318 through regular synchronizations, broadcast subscriptions, and the like. NRF 318 may be a micro-service among back end services 302 or may be located elsewhere within the network environment 300.

A network function and service management service 322 provides an interface layer between signal routing engine 320 and a service bus interface 316. Network function and service management 322 includes procedures for converting a received signal formatted as a REST API call or the like into an appropriate service protocol call. Further, network function and service management service 322 may transmit the reformatted signal to the appropriate endpoint as determined by forwarding table 324 and/or HTTP/2 routing management service 328.

The converted signal may proceed along service bus interface 316 to and within services back end 302 in order to be received by the intended micro-service or micro-services. For example, an attach procedure as described above may be transmitted AMF-1 312 or AMF-2 308. Further, service bus interface 316 may transport signals from back end services 302 to signal routing engine 320 to, for example, return a response to a requestor. In some examples, any communications between micro-services may also be passed first to signal routing engine 320 via the service bus interface 316 and then relayed to the intended micro-service recipient in order to minimize overhead and size of each micro-service and centralize all communications into a hub-and-spoke model (e.g., signal routing engine 320 being the hub).

FIG. 4 depicts a call sequence diagram 400 illustrating an attach procedure performed using signal routing engine 320. Here, a global SRE 404 maintains a globally applicable SRE state and SREs 408 and 414 maintain a portion of the state of global SRE 404 in order to manage signals over, for example, a particular network slice or a particular network geographic region and the like. In particular, call sequence diagram 400 illustrates SRE cache maintenance and attachment procedures.

Global SRE 404 transmits a signal 4.01 to a NRF 420 in order to discover available network functions and the like or to retrieve updated information on available services and endpoints within the network. In one embodiment, signal 4.01 include a REST API call with a GET statement such as “GET/nrf/v1/nrf-disco/search” and the like. In response, NRF 420 returns to global SRE 404 a signal 4.02 including a list of NFs and NF endpoint information (e.g., IP addresses and the like).

As a result, global SRE 404 transmits a signal 4.03 to itself in order to perform a cache maintenance. In one embodiment, the cache maintenance updates the stored listing of global NFs (e.g., for each network slice) to remove services no longer available and add newly provided services or update IP addresses for updated services. In some examples, global SRE 404 can be a micro-service architecture itself, in which case one subservice may transmit signal 4.03 to another subservice within the SRE 404 micro-services construction.

Global SRE 404 may then send updated copies of respective portions of the updated lists to SRE 408, 414, and 418 respectively via signals 4.04, 4.05, and 4.06 respectively. The respective portions of the updated lists may be determined based on, for example and without imputing limitation, the respective network slice for which the target SRE is responsible. While SRE 408, 414, and 418 are depicted here as receiving updates via global SRE 404, it will be understood by a person having ordinary skill in the art that, alternatively or in addition, SRE 408, 414, and 418 may receive updates directly from NRF 420 and the like.

At some later time, UE 402 may transmit to AMF 406 a signal 4.07 to attach to a particular network. For example, UE 402 may be a smartphone or the like on the move and passing between networks. As UE 402 enters a new network coverage area, an attach procedure may be initiated in order to fully join that network.

Once AMF 406 has received signal 4.07, it may transmit signal 4.08 to SRE 408 in order to identify a network slice to which UE 402 may attach. Signal 4.08 may be a low overhead signal such as, for example and without imputing limitation, gRPC and the like which provide high performance procedure call frameworks. SRE 408 may forward the received signal to NSSF 410 as a signal 4.09 according to an updated forwarding table such as forwarding table 324 discussed above. In response, NSSF 410 may then transmit slice information via signal 4.10 back to SRE 408, which in turn may forward the response to AMF 406 via signal 4.11 in order to provide AMF 406 the slice information.

AMF 406 can then use the slice information to transmit a signal 4.12 for creating a new session, or protocol data unit (PDU) context, with SMF 412. SMF 412 may respond by retrieving QoS information necessary to determine an appropriate service level at which to set the session. SMF 412 can do this by transmitting signal 4.13 to SRE 414, which may be a routing engine specialized in a particular network slice (e.g., QoS matter and the like). SRE 414 may then relay the QoS information request to PCF 416 via signal 4.14, which in turn may transmit the requested QoS information back to SRE 414 via signal 4.15. As a result, SRE 414 may transmit the QoS information via signal 4.16 to SMF 412.

Having received the QoS information, SMF 412 may produce a session, or PDU connect, for UE 402. Notification and the like may be transmitted to AMF 406 from SMF 412 via signal 4.17. In some examples, the notification may include further information for maintaining the session and the like. AMF 406 can then notify UE 402 that the attach procedure has completed via signal 4.18.

FIG. 5 depicts a method 500 by which, for example, signal routing engine 302 and the like may perform, for example, call sequence 400. While method 500 is depicted as ordered blocks, it is understood that said blocks may be ordered differently than depicted and some blocks may not be performed while additional blocks not depicted may be additionally performed without straying from the disclosed invention.

A network function (NF) endpoint address may be stored in a router forwarding table (operation 502). In one embodiment, the forwarding table may be forwarding table 324 within signal routing engine 320. Further, NRF 318 may provide the NF endpoint address through an update procedure or the like.

Signal routing engine 320, for example, may then receive from a requesting service an API call directed to the NF endpoint stored in the table (operation 504).

The received API call may be converted into a micro-services protocol call (operation 506). In one embodiment, network function and service management service 322 may perform the conversion. In some examples, multiple micro-services protocols may be used and network function and service management service 322 may convert the API call to an appropriate micro-services protocol call based on which NF endpoint the call is directed to and the like.

Signal routing engine 320 can then transmit the converted call to the NF endpoint (operation 508). In one embodiment, network function and service management service 322 can transmit the converted call over service bus interface 316, which may be a hardware bus, virtual bus, or otherwise as will be apparent to a person having ordinary skill in the art.

In response, signal routing engine 320 may receive a response to the transmitted call from the NF endpoint (operation 510). The received response may then be converted into the same format as the received API call and transmitted to the requesting service (operation 512). In one embodiment, signal routing engine 320 may convert the response back into the original API call format by, for example, applying an inverted conversion process via network function and service management service 322. For example, network function and service management service 322 may include logic to convert to various formats based on transmission direction. In other examples, processes may be flagged and associated with a stack or the like which may be associated with conversion processes in order to maintain fluid and responsive signal routing between external processes and back end service micro-services. By decoupling complex parsing and routing from micro-services, each micro-service is thus able to more efficiently process procedure calls and so reduce latency, responsiveness, and the like.

The disclosure now turns to FIGS. 6 and 7, which illustrate example network and computing devices, such as switches, routers, load balancers, client computers, and so forth.

FIG. 6 illustrates an example network device 600 suitable for performing switching, routing, and other networking operations. Network device 600 includes a central processing unit (CPU) 604, interfaces 602, and a connection 610 (e.g., a PCI bus). When acting under the control of appropriate software or firmware, the CPU 604 is responsible for executing packet management, error detection, and/or routing functions. The CPU 604 preferably accomplishes all these functions under the control of software including an operating system and any appropriate applications software. CPU 604 may include one or more processors 608, such as a processor from the INTEL X86 family of microprocessors. In some cases, processor 608 can be specially designed hardware for controlling the operations of network device 600. In some cases, a memory 606 (e.g., non-volatile RAM, ROM, TCAM, and the like) also forms part of CPU 604. However, there are many different ways in which memory could be coupled to the system. In some cases, the network device 600 can include a memory and/or storage hardware, such as TCAM, separate from CPU 604. Such memory and/or storage hardware can be coupled with the network device 600 and its components via, for example, connection 610.

The interfaces 602 are typically provided as modular interface cards (sometimes referred to as “line cards”). Generally, they control the sending and receiving of data packets over the network and sometimes support other peripherals used with the network device 600. Among the interfaces that may be provided are Ethernet interfaces, frame relay interfaces, cable interfaces, DSL interfaces, token ring interfaces, and the like. In addition, various very high-speed interfaces may be provided such as fast token ring interfaces, wireless interfaces, Ethernet interfaces, Gigabit Ethernet interfaces, ATM interfaces, HSSI interfaces, POS interfaces, FDDI interfaces, WIFI interfaces, 3G/4G/5G cellular interfaces, CAN BUS, LoRA, and the like. Generally, these interfaces may include ports appropriate for communication with the appropriate media. In some cases, they may also include an independent processor and, in some instances, volatile RAM. The independent processors may control such communications intensive tasks as packet switching, media control, signal processing, encryption processing, and management. By providing separate processors for the communications intensive tasks, these interfaces allow the master microprocessor 604 to efficiently perform routing computations, network diagnostics, security functions, etc.

Although the system shown in FIG. 6 is one specific network device of the present disclosure, it is by no means the only network device architecture on which the concepts herein can be implemented. For example, an architecture having a single processor that handles communications as well as routing computations, etc., can be used. Further, other types of interfaces and media could also be used with the network device 600.

Regardless of the network device's configuration, it may employ one or more memories or memory modules (including memory 606) configured to store program instructions for the general-purpose network operations and mechanisms for roaming, route optimization and routing functions described herein. The program instructions may control the operation of an operating system and/or one or more applications, for example. The memory or memories may also be configured to store tables such as mobility binding, registration, and association tables, etc. Memory 606 could also hold various software containers and virtualized execution environments and data.

The network device 600 can also include an application-specific integrated circuit (ASIC), which can be configured to perform routing, switching, and/or other operations. The ASIC can communicate with other components in the network device 600 via the connection 610, to exchange data and signals and coordinate various types of operations by the network device 600, such as routing, switching, and/or data storage operations, for example.

FIG. 7 illustrates a computing system architecture 700 including components in electrical communication with each other using a connection 705, such as a bus. System 700 includes a processing unit (CPU or processor) 710 and a system connection 705 that couples various system components including the system memory 715, such as read only memory (ROM) 720 and random access memory (RAM) 725, to the processor 710. The system 700 can include a cache of high-speed memory connected directly with, in close proximity to, or integrated as part of the processor 710. The system 700 can copy data from the memory 715 and/or the storage device 730 to the cache 712 for quick access by the processor 710. In this way, the cache can provide a performance boost that avoids processor 710 delays while waiting for data. These and other modules can control or be configured to control the processor 710 to perform various actions. Other system memory 715 may be available for use as well. The memory 715 can include multiple different types of memory with different performance characteristics. The processor 710 can include any general purpose processor and a hardware or software service, such as service 1 732, service 2 734, and service 3 736 stored in storage device 730, configured to control the processor 710 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. The processor 710 may be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, and the like. A multi-core processor may be symmetric or asymmetric.

To enable user interaction with the computing device 700, an input device 745 can represent any number of input mechanisms, such as a microphone for speech, a touch-sensitive screen for gesture or graphical input, keyboard, mouse, motion input, speech and so forth. An output device 735 can also be one or more of a number of output mechanisms known to those of skill in the art. In some instances, multimodal systems can enable a user to provide multiple types of input to communicate with the computing device 700. The communications interface 740 can generally govern and manage the user input and system output. There is no restriction on operating on any particular hardware arrangement and therefore the basic features here may easily be substituted for improved hardware or firmware arrangements as they are developed.

Storage device 730 is a non-volatile memory and can be a hard disk or other types of computer readable media which can store data that are accessible by a computer, such as magnetic cassettes, flash memory cards, solid state memory devices, digital versatile disks, cartridges, random access memories (RAMs) 725, read only memory (ROM) 720, and hybrids thereof.

The storage device 730 can include services 732, 734, 736 for controlling the processor 710. Other hardware or software modules are contemplated. The storage device 730 can be connected to the system connection 705. In one aspect, a hardware module that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as the processor 710, connection 705, output device 735, and so forth, to carry out the function.

For clarity of explanation, in some instances the present technology may be presented as including individual functional blocks including functional blocks comprising devices, device components, steps or routines in a method embodied in software, or combinations of hardware and software.

In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.

Methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer readable media. Such instructions can comprise, for example, instructions and data which cause or otherwise configure a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, or source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on.

Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include laptops, smart phones, small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are means for providing the functions described in these disclosures.

Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims.

Claim language reciting “at least one of” refers to at least one of a set and indicates that one member of the set or multiple members of the set satisfy the claim. For example, claim language reciting “at least one of A and B” means A, B, or A and B. 

What is claimed is:
 1. A method for managing service calls across a network, the method comprising: retrieving, by a global source routing engine (SRE) and from a network repository function (NRF), a list comprising network functions (NFs) and endpoint addresses associated with respective NFs, the global SRE comprising a forwarding table; storing, in the forwarding table, the retrieved list; transmitting, by the global SRE and to a target SRE, a portion of the list, a portion of the list related to a network slice for which the target SRE is responsible; receiving, by the target SRE and from an access function (AMF), a request for slice information, the request for slice information including a user equipment (UE) identifier; and providing, by the target SRE and to the AMF, a response including the slice information for attaching the UE to a network slice identified by the slice information.
 2. The method of claim 1, further comprising retrieving, by the target SRE and from a network slice selection function (NSSF), slice information in response to the request for slice information.
 3. The method of claim 1, further comprising: transmitting, by the AMF and to a session management function (SMF), a command for creating a protocol data unit (PDU) context; and receiving, by the AMF and from the SMF, a PDU context for attaching the UE to the network slice identified by the slice information.
 4. The method of claim 3, further comprising: receiving, by a second target SRE and from the SMF, a request for quality of service (QOS) information; retrieving, by the second target SRE, QOS information from a policy control function (PCF) based on the received request for QOS information; and transmitting, to the SMF, the retrieved QOS information for creating the PDU context.
 5. The method of claim 1, further comprising: receiving, by the target SRE, an application programming interface (API) call directed to a NF of the list comprising NFs and endpoint addresses, the API call formatted in a web protocol; converting, by the target SRE, the API call from the web protocol format to a micro-services protocol format; and transmitting, by the target SRE and to the NF, the converted API call based on an endpoint address associated with the NF, the endpoint address from the list comprising NFs and endpoint addresses.
 6. The method of claim 5, further comprising: receiving, by the target SRE and from the NF, a response to the transmitted converted API call, the response in a micro-services protocol format; converting, by the target SRE, the received response to the transmitted API call into web protocol format; and transmitting, by the target SRE and to a destination service, the web protocol formatted response to the transmitted API call.
 7. The method of claim 5, wherein the micro-services protocol format is gRPC and the web protocol format is HTTP/2.
 8. A system for managing service calls across a network, the system comprising: a global source routing engine (SRE) comprising a forwarding table; a network repository function (NRF) in communication with the global SRE, the global SRE retrieving from the NRF a list comprising network functions (NFs) and endpoint addresses associated with respective NFs; a target SRE in communication with the global SRE, the global SRE transmitting to the target SRE a portion of the list related to a network slice for which the target SRE is responsible; and an access function (AMF) in communication with the target SRE, the target SRE receiving from the AMF a request for slice information, the request for slice information including a user equipment (UE) identifier; wherein the target SRE provides to the AMF a response including the slice information for attaching the UE to a network slice identified by the slice information.
 9. The system of claim 8, further comprising a network slice selection function (NSSF), wherein the target SRE retrieves from the NSSF slice information in response to the request for slice information.
 10. The system of claim 8, further comprising a session management function (SMF) in communication with the AMF, the AMF transmitting to the SMF a command for creating a protocol data unit (PDU) context, wherein the AMF receives from the SMF a PDU context for attaching the UE to the network slice identified by the slice information.
 11. The system of claim 10, further comprising: a second target SRE in communication with the SMF, the second target SRE receiving from the SMF a request for a quality of service (QOS) information; and a policy control function (PCF) in communication with the second target SRE, the second target SRE retrieving from the PCF QOS information based on the received request for QOS information, and the SMF receives the retrieved QOS information for creating the PDU context.
 12. The system of claim 8, wherein: the target SRE receives an application programming interface (API) call directed to a NF of the list comprising NFs and endpoint addresses, the API call formatted in a web protocol; and the target SRE converts the API call from the web protocol format to a micro-services protocol format and transmits to the NF the converted API call based on an endpoint address associated with the NF, the endpoint address from the list comprising NFs and endpoint addresses.
 13. The system of claim 12, further comprising a destination service and wherein: the target SRE receives from the NF a response to the transmitted converted API call, the response in a micro-services protocol format; and the target SRE converts the received response to the transmitted API call into web protocol format and transmits to the destination service the web protocol formatted response to the transmitted API call.
 14. The system of claim 12, wherein the micro-services protocol is gRPC and the web protocol is HTTP/2.
 15. A non-transitory computer readable medium comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to: retrieve, by a global source routing engine (SRE) and from a network repository function (NRF), a list comprising network functions (NFs) and endpoint addresses associated with respective NFs, the global SRE comprising a forwarding table; store, in the forwarding table, the retrieved list; transmit, by the global SRE and to a target SRE, a portion of the list, a portion of the list related to a network slice for which the target SRE is responsible; receive, by the target SRE and from an access function (AMF), a request for slice information, the request for slice information including a user equipment (UE) identifier; and provide, by the target SRE and to the AMF, a response including the slice information for attaching the UE to a network slice identified by the slice information.
 16. The non-transitory computer readable medium of claim 15, further comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to retrieve, by the target SRE and from a network slice selection function (NSSF), slice information in response to the request for slice information.
 17. The non-transitory computer readable medium of claim 15, further comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to: transmit, by the AMF and to a session management function (SMF), a command for creating a protocol data unit (PDU) context; and receive, by the AMF and from the SMF, a PDU context for attaching the UE to the network slice identified by the slice information.
 18. The non-transitory computer readable medium of claim 17, further comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to: receive, by a second target SRE and from the SMF, a request for quality of service (QOS) information; retrieve, by the second target SRE, QOS information from a policy control function (PCF) based on the received request for QOS information; and transmit, to the SMF, the retrieved QOS information for creating the PDU context.
 19. The non-transitory computer readable medium of claim 15, further comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to: receive, by the target SRE, an application programming interface (API) call directed to a NF of the list comprising NFs and endpoint addresses, the API call formatted in a web protocol; convert, by the target SRE, the API call from the web protocol format to a micro-services protocol format; and transmit, by the target SRE and to the NF, the converted API call based on an endpoint address associated with the NF, the endpoint address from the list comprising NFs and endpoint addresses.
 20. The non-transitory computer readable medium of claim 19, further comprising instructions that, when executed by one or more processors configured for network management, cause the one or more processors to: receive, by the target SRE and from the NF, a response to the transmitted converted API call, the response in a micro-services protocol format; convert, by the target SRE, the received response to the transmitted API call into web protocol format; and transmit, by the target SRE and to a destination service, the web protocol formatted response to the transmitted API call. 